diff --git a/system/libraries/Session.php b/system/libraries/Session.php
index a92db0e..2cdd50c 100644
--- a/system/libraries/Session.php
+++ b/system/libraries/Session.php
@@ -69,8 +69,8 @@
 		 * is set in the config file.  If the developer
 		 * is doing any sort of time localization they
 		 * might want to set the session time to GMT so
-		 * they can offset the "last_activity" and
-		 * "last_visit" times based on each user's locale.
+		 * they can offset the "last_activity" time
+		 * based on each user's locale.
 		 *
 		 */
 
@@ -326,7 +326,6 @@
 		}
 			
 		// Write the cookie
-		$this->userdata['last_visit'] = 0;
 		$this->sess_write();
 	}
 	
@@ -340,11 +339,6 @@
 	 */
 	function sess_update()
 	{	
-		if (($this->userdata['last_activity'] + $this->sess_length) < $this->now)
-		{
-			$this->userdata['last_visit'] = $this->userdata['last_activity'];
-		}
-
 		// Save the old session id so we know which record to 
 		// update in the database if we need it
 		$old_sessid = $this->userdata['session_id'];
diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 1affd9d..c37b095 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -114,6 +114,7 @@
 			<li>Changed the load protocol of Models to allow for extension.</li>
 			<li>Strengthened the Encryption library to help protect against man in the middle attacks when MCRYPT_MODE_CBC mode is used.</li>
 			<li>Added Flashdata variables, session_id regeneration and configurable session update times to the <a href="./libraries/sessions.html">Session class.</a></li>
+			<li>Removed 'last_visit' from the Session class.</li>
 			<li>Added a language entry for valid_ip validation error.</li>
 		    <li>Modified prep_for_form() in the Validation class to accept arrays, adding support for POST array validation (via callbacks only)</li>
 		    <li>Added an &quot;integer&quot; rule into the <a href="./libraries/validation.html">Validation</a> library.</li>
